home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / telecomm / uemlsrc.arc / kerrec.c < prev    next >
C/C++ Source or Header  |  1987-08-24  |  16KB  |  424 lines
  1. /* kerrec.c kermit protocol file receive support.
  2.  */
  3.  
  4. #include <stdio.h>
  5. #include <osbind.h>
  6. #include "ed.h"
  7. #include "kermit.h"
  8.  
  9. extern char getfiln[NFILEN];
  10.  
  11. /*
  12. *      r e c s w
  13. *
  14. * This is the state table switcher for receiving files.
  15. */
  16.  
  17. recsw()
  18. {
  19.  
  20.         state = 'R';                /* Receive-Init is the start state */
  21.         n = np = 0;                       /* Initialize message number */
  22.         numtry = 0;                  /* Say no tries yet */
  23.  
  24.         while(TRUE)
  25.         {
  26.         switch(state)              /* Do until done */
  27.                 {
  28.                 case 'R':
  29.                         state = rinit();
  30.                         mlwrite("[Awaiting remote init]");
  31.                         break; /* Receive-Init */
  32.                 case 'F':
  33.                         state = rfile();
  34.                         break; /* Receive-File */
  35.                 case 'D':
  36.                         state = rdata();
  37.                         break; /* Receive-Data */
  38.                 case 'C':
  39.                         return(TRUE);      /* Complete state */
  40.                 case 'A':
  41.                         return(FALSE);    /* "Abort" state */
  42.                 }
  43.         }
  44. }
  45.  
  46. /*
  47.  * astget.c server function GET
  48.  * implemented by B. Nebel
  49.  */
  50. getsw()
  51. {
  52.         int result;
  53.  
  54.         flushinput();
  55.         spack('R',0,strlen(getfiln),getfiln);
  56.         result = recsw();
  57.         return (result);
  58. }
  59.  
  60. /*
  61. *      r i n i t
  62. *
  63. * Receive Initialization
  64. */
  65.  
  66. char rinit()
  67. {
  68.         int len, num;              /* Packet length, number */
  69.  
  70.         if (numtry++ > MAXTRY) return('A');     /* If too many tries, "abort" */
  71.  
  72.         switch(rpack(&len,&num,packet))  /* Get a packet */
  73.         {
  74.         case 'S':                      /* Send-Init */
  75.                 rpar(packet,len);       /* Get the other side's init data */
  76.                 len = spar(packet);     /* Fill up packet with my init info */
  77.                 spack('Y',n,len,packet);        /* ACK with my parameters */
  78.                 oldtry = numtry;                /* Save old try count */
  79.                 numtry = 0;                  /* Start a new counter */
  80.                 n = (n+1)%64;      /* Bump packet number, mod 64 */
  81.                 return('F');        /* Enter File-Receive state */
  82.  
  83.         case 'E':                      /* Error packet received */
  84.                 prerrpkt(recpkt);       /* Print it out and */
  85.                 return('A');        /* abort */
  86.  
  87.         case FALSE:                  /* Didn't get packet */
  88.                 spack('N',n,0,NULLPTR);    /* Return a NAK */
  89.                 return(state);    /* Keep trying */
  90.  
  91.         default:
  92.                 return('A');        /* Some other packet type, "abort" */
  93.         }
  94. }
  95.  
  96.  
  97. /*
  98. *      r f i l e
  99. *
  100. * Receive File Header
  101. */
  102.  
  103. char rfile()
  104. {
  105.         int num, len;              /* Packet number, length */
  106.  
  107.         if (numtry++ > MAXTRY) return('A');     /* "abort" if too many tries */
  108.  
  109.         switch(rpack(&len,&num,packet))  /* Get a packet */
  110.         {
  111.         case 'S':                      /* Send-Init, maybe our ACK lost */
  112.                 /* If too many tries "abort" */
  113.                 if (oldtry++ > MAXTRY) return('A');
  114.                 if (num == ((n==0) ? 63:n-1)) /* Previous packet, mod 64? */
  115.                 {                              /* Yes, ACK it again with */
  116.                         len = spar(packet);     /* our Send-Init parameters */
  117.                         spack('Y',num,len,packet);
  118.                         numtry = 0;          /* Reset try counter */
  119.                         return(state);    /* Stay in this state */
  120.                 }
  121.                 else return('A');       /* Not previous packet, "abort" */
  122.  
  123.         case 'Z':                      /* End-Of-File */
  124.                 if (oldtry++ > MAXTRY) return('A');
  125.                 if (num == ((n==0) ? 63:n-1)) /* Previous packet, mod 64? */
  126.                 {                              /* Yes, ACK it again. */
  127.                         spack('Y',num,0,NULLPTR);
  128.                         numtry = 0;
  129.                         return(state);    /* Stay in this state */
  130.                 }
  131.                 else return('A');       /* Not previous packet, "abort" */
  132.  
  133.         case 'F':                      /* File Header (just what we want) */
  134.                 /* The packet number must be right */
  135.                 if (num != n) return('A');
  136.                 mlwrite("[Receiving %s as %s]",packet,curbp->b_bname);
  137.  
  138.                 spack('Y',n,0,NULLPTR);    /* Acknowledge the file header */
  139.                 oldtry = numtry;        /* Reset try counters */
  140.                 numtry = 0;
  141.                 n = (n+1)%64;      /* Bump packet number, mod 64 */
  142.                 return('D');        /* Switch to Data state */
  143.  
  144.         case 'B':                      /* Break transmission (EOT) */
  145.                 if (num != n) return ('A'); /* Need right packet number here */
  146.                 spack('Y',n,0,NULLPTR);     /* Say OK */
  147.                 return('C');        /* Go to complete state */
  148.  
  149.         case 'E':                      /* Error packet received */
  150.                 prerrpkt(recpkt);       /* Print it out and */
  151.                 return('A');        /* abort */
  152.  
  153.         case FALSE:                  /* Didn't get packet */
  154.                 spack('N',n,0,NULLPTR);    /* Return a NAK */
  155.                 return(state);    /* Keep trying */
  156.  
  157.         default:
  158.                 return ('A');      /* Some other packet, "abort" */
  159.         }
  160. }
  161.  
  162.  
  163. /*
  164. *      r d a t a
  165. *
  166. * Receive Data
  167. */
  168.  
  169. char rdata()
  170. {
  171.         int num, len;              /* Packet number, length */
  172.         if (numtry++ > MAXTRY) return('A');     /* "abort" if too many tries */
  173.  
  174.         switch(rpack(&len,&num,packet))  /* Get packet */
  175.         {
  176.         case 'D':                      /* Got Data packet */
  177.                 if (num != n)      /* Right packet? */
  178.                 {                              /* No */
  179.                         if (oldtry++ > MAXTRY)
  180.                                 return('A');    /* If too many tries, abort */
  181.                         if (num == ((n==0) ? 63:n-1))
  182.                         { /* Else check previous packet again? */
  183.                                 spack('Y',num,0,NULLPTR); /* Yes, re-ACK it */
  184.                                 numtry = 0;     /* Reset try counter */
  185.                                 return(state);  /* Don't write out data! */
  186.                         }
  187.                         else return('A');       /* sorry, wrong number */
  188.                 }
  189.                 /* Got data with right packet number */
  190.                 bufemp(packet,len);          /* Write the data to the file */
  191.                 spack('Y',n,0,NULLPTR);     /* Acknowledge the packet */
  192.                 oldtry = numtry;                /* Reset the try counters */
  193.                 numtry = 0;                  /* ... */
  194.                 mlwrite("[Receiving packet: %d]", ++np);
  195.                 n = (n+1)%64;      /* Bump packet number, mod 64 */
  196.                 return('D');        /* Remain in data state */
  197.  
  198.         case 'F':                      /* Got a File Header */
  199.                 if (oldtry++ > MAXTRY)
  200.                         return('A');        /* If too many tries, "abort" */
  201.                 if (num == ((n==0) ? 63:n-1))   /* Else check packet number */
  202.                 {                              /* It was the previous one */
  203.                         spack('Y',num,0,NULLPTR);  /* ACK it again */
  204.                         numtry = 0;          /* Reset try counter */
  205.                         return(state);    /* Stay in Data state */
  206.                 }
  207.                 else return('A');       /* Not previous packet, "abort" */
  208.  
  209.         case 'Z':                      /* End-Of-File */
  210.                 /* Must have right packet number */
  211.                 if (num != n) return('A');
  212.                 spack('Y',n,0,NULLPTR);     /* OK, ACK it. */
  213.                 n = (n+1)%64;      /* Bump packet number */
  214.                 return('F');        /* Go back to Receive File state */
  215.  
  216.         case 'E':                      /* Error packet received */
  217.                 prerrpkt(recpkt);              /* Print it out and */
  218.                 return